home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 7: Sunsite / Linux Cubed Series 7 - Sunsite Vol 1.iso / system / network / base / netkit-b.07a / netkit-b / NetKit-B-0.07A / rcp / rcp.c < prev   
Encoding:
C/C++ Source or Header  |  1996-07-22  |  18.5 KB  |  849 lines
  1. /*
  2.  * Copyright (c) 1983, 1990 The Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *    This product includes software developed by the University of
  16.  *    California, Berkeley and its contributors.
  17.  * 4. Neither the name of the University nor the names of its contributors
  18.  *    may be used to endorse or promote products derived from this software
  19.  *    without specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  */
  33.  
  34. char copyright[] =
  35.  "@(#) Copyright (c) 1983, 1990 The Regents of the University of California.\n"
  36.  "All rights reserved.\n";
  37.  
  38. /*
  39.  * From: @(#)rcp.c    5.32 (Berkeley) 2/25/91
  40.  */
  41. char rcsid[] = "$Id: rcp.c,v 1.5 1996/07/22 01:01:36 dholland Exp $";
  42.  
  43. /*
  44.  * rcp
  45.  */
  46. #include <sys/param.h>
  47. #include <sys/stat.h>
  48. #include <sys/time.h>
  49. #include <sys/ioctl.h>
  50. #include <sys/socket.h>
  51. #include <sys/wait.h>
  52. #include <netinet/in.h>
  53. #include <netinet/ip.h>
  54. #include <dirent.h>
  55. #include <fcntl.h>
  56. #include <signal.h>
  57. #include <pwd.h>
  58. #include <netdb.h>
  59. #include <errno.h>
  60. #include <unistd.h>
  61. #include <stdio.h>
  62. #include <stdarg.h>
  63. #include <stdlib.h>
  64. #include <string.h>
  65. #include <ctype.h>
  66. #include "pathnames.h"
  67.  
  68. #define    OPTIONS "dfprt"
  69.  
  70. struct passwd *pwd;
  71. u_short    port;
  72. uid_t    userid;
  73. int errs, rem;
  74. int pflag, iamremote, iamrecursive, targetshouldbedirectory;
  75.  
  76. #define    CMDNEEDS    64
  77. char cmd[CMDNEEDS];        /* must hold "rcp -r -p -d\0" */
  78.  
  79. typedef struct _buf {
  80.     int    cnt;
  81.     char    *buf;
  82. } BUF;
  83.  
  84. static void lostconn(int);
  85. static char *colon(char *);
  86. static int response(void);
  87. static void verifydir(const char *cp);
  88. static int okname(const char *cp0);
  89. static int susystem(const char *s);
  90. static void source(int argc, char *argv[]);
  91. static void rsource(char *name, struct stat *statp);
  92. static void sink(int argc, char *argv[]);
  93. static BUF *allocbuf(BUF *bp, int fd, int blksize);
  94. static void nospace(void);
  95. static void usage(void);
  96. static void toremote(char *targ, int argc, char *argv[]);
  97. static void tolocal(int argc, char *argv[]);
  98. static void error(const char *fmt, ...);
  99.  
  100. int
  101. main(int argc, char *argv[])
  102. {
  103.     extern int optind;
  104.     extern char *optarg;
  105.     struct servent *sp;
  106.     int ch, fflag, tflag;
  107.     char *targ, *shell;
  108.  
  109.     fflag = tflag = 0;
  110.     while ((ch = getopt(argc, argv, OPTIONS)) != EOF)
  111.         switch(ch) {
  112.         /* user-visible flags */
  113.         case 'p':            /* preserve access/mod times */
  114.             ++pflag;
  115.             break;
  116.         case 'r':
  117.             ++iamrecursive;
  118.             break;
  119.         /* rshd-invoked options (server) */
  120.         case 'd':
  121.             targetshouldbedirectory = 1;
  122.             break;
  123.         case 'f':            /* "from" */
  124.             iamremote = 1;
  125.             fflag = 1;
  126.             break;
  127.         case 't':            /* "to" */
  128.             iamremote = 1;
  129.             tflag = 1;
  130.             break;
  131.  
  132.         case '?':
  133.         default:
  134.             usage();
  135.         }
  136.     argc -= optind;
  137.     argv += optind;
  138.  
  139.     sp = getservbyname(shell = "shell", "tcp");
  140.     if (sp == NULL) {
  141.         (void)fprintf(stderr, "rcp: %s/tcp: unknown service\n", shell);
  142.         exit(1);
  143.     }
  144.     port = sp->s_port;
  145.  
  146.     if (!(pwd = getpwuid(userid = getuid()))) {
  147.         (void)fprintf(stderr, "rcp: unknown user %d.\n", (int)userid);
  148.         exit(1);
  149.     }
  150.  
  151.     if (fflag) {
  152.         /* follow "protocol", send data */
  153.         (void)response();
  154.         (void)setuid(userid);
  155.         source(argc, argv);
  156.         exit(errs);
  157.     }
  158.  
  159.     if (tflag) {
  160.         /* receive data */
  161.         (void)setuid(userid);
  162.         sink(argc, argv);
  163.         exit(errs);
  164.     }
  165.  
  166.     if (argc < 2)
  167.         usage();
  168.     if (argc > 2)
  169.         targetshouldbedirectory = 1;
  170.  
  171.     rem = -1;
  172.     /* command to be executed on remote system using "rsh" */
  173.     (void)snprintf(cmd, sizeof(cmd), "rcp%s%s%s",
  174.         iamrecursive ? " -r" : "", pflag ? " -p" : "",
  175.         targetshouldbedirectory ? " -d" : "");
  176.  
  177.     (void)signal(SIGPIPE, lostconn);
  178.  
  179.     if ((targ = colon(argv[argc - 1]))!=NULL)
  180.         toremote(targ, argc, argv);    /* destination is remote host */
  181.     else {
  182.         tolocal(argc, argv);        /* destination is local host */
  183.         if (targetshouldbedirectory)
  184.             verifydir(argv[argc - 1]);
  185.     }
  186.     exit(errs);
  187. }
  188.  
  189. static void
  190. toremote(char *targ, int argc, char *argv[])
  191. {
  192.     int i, len, tos;
  193.     char *bp, *host, *src, *suser, *thost, *tuser;
  194.  
  195.     *targ++ = 0;
  196.     if (*targ == 0)
  197.         targ = ".";
  198.  
  199.     if ((thost = strchr(argv[argc - 1], '@'))!=NULL) {
  200.         /* user@host */
  201.         *thost++ = 0;
  202.         tuser = argv[argc - 1];
  203.         if (*tuser == '\0')
  204.             tuser = NULL;
  205.         else if (!okname(tuser))
  206.             exit(1);
  207.     } else {
  208.         thost = argv[argc - 1];
  209.         tuser = NULL;
  210.     }
  211.  
  212.     for (i = 0; i < argc - 1; i++) {
  213.         src = colon(argv[i]);
  214.         if (src) {            /* remote to remote */
  215.             *src++ = 0;
  216.             if (*src == 0)
  217.                 src = ".";
  218.             host = strchr(argv[i], '@');
  219.             len = strlen(_PATH_RSH) + strlen(argv[i]) +
  220.                 strlen(src) + (tuser ? strlen(tuser) : 0) +
  221.                 strlen(thost) + strlen(targ) + CMDNEEDS + 20;
  222.             if (!(bp = malloc(len)))
  223.                 nospace();
  224.             if (host) {
  225.                 *host++ = 0;
  226.                 suser = argv[i];
  227.                 if (*suser == '\0')
  228.                     suser = pwd->pw_name;
  229.                 else if (!okname(suser))
  230.                     continue;
  231.                 (void)snprintf(bp, len,
  232.                     "%s %s -l %s -n %s %s '%s%s%s:%s'",
  233.                     _PATH_RSH, host, suser, cmd, src,
  234.                     tuser ? tuser : "", tuser ? "@" : "",
  235.                     thost, targ);
  236.             } else
  237.                 (void)snprintf(bp, len,
  238.                     "%s %s -n %s %s '%s%s%s:%s'",
  239.                     _PATH_RSH, argv[i], cmd, src,
  240.                     tuser ? tuser : "", tuser ? "@" : "",
  241.                     thost, targ);
  242.             (void)susystem(bp);
  243.             (void)free(bp);
  244.         } else {            /* local to remote */
  245.             if (rem == -1) {
  246.                 len = strlen(targ) + CMDNEEDS + 20;
  247.                 if (!(bp = malloc(len)))
  248.                     nospace();
  249.                 (void)snprintf(bp, len, "%s -t %s", cmd, targ);
  250.                 host = thost;
  251.                     rem = rcmd(&host, port, pwd->pw_name,
  252.                         tuser ? tuser : pwd->pw_name,
  253.                         bp, 0);
  254.                 if (rem < 0)
  255.                     exit(1);
  256. #ifdef IP_TOS
  257.                 tos = IPTOS_THROUGHPUT;
  258.                 if (setsockopt(rem, IPPROTO_IP, IP_TOS,
  259.                     (char *)&tos, sizeof(int)) < 0)
  260.                     perror("rcp: setsockopt TOS (ignored)");
  261. #endif
  262.                 if (response() < 0)
  263.                     exit(1);
  264.                 (void)free(bp);
  265.                 (void)setuid(userid);
  266.             }
  267.             source(1, argv+i);
  268.         }
  269.     }
  270. }
  271.  
  272. static void
  273. tolocal(int argc, char *argv[])
  274. {
  275.     int i, len, tos;
  276.     char *bp, *host, *src, *suser;
  277.  
  278.     for (i = 0; i < argc - 1; i++) {
  279.         if (!(src = colon(argv[i]))) {    /* local to local */
  280.             len = strlen(_PATH_CP) + strlen(argv[i]) +
  281.                 strlen(argv[argc - 1]) + 20;
  282.             if (!(bp = malloc(len)))
  283.                 nospace();
  284.             (void)snprintf(bp, len, "%s%s%s %s %s", _PATH_CP,
  285.                 iamrecursive ? " -r" : "", pflag ? " -p" : "",
  286.                 argv[i], argv[argc - 1]);
  287.             (void)susystem(bp);
  288.             (void)free(bp);
  289.             continue;
  290.         }
  291.         *src++ = 0;
  292.         if (*src == 0)
  293.             src = ".";
  294.         host = strchr(argv[i], '@');
  295.         if (host) {
  296.             *host++ = 0;
  297.             suser = argv[i];
  298.             if (*suser == '\0')
  299.                 suser = pwd->pw_name;
  300.             else if (!okname(suser))
  301.                 continue;
  302.         } else {
  303.             host = argv[i];
  304.             suser = pwd->pw_name;
  305.         }
  306.         len = strlen(src) + CMDNEEDS + 20;
  307.         if (!(bp = malloc(len)))
  308.             nospace();
  309.         (void)snprintf(bp, len, "%s -f %s", cmd, src);
  310.             rem = rcmd(&host, port, pwd->pw_name, suser, bp, 0);
  311.         (void)free(bp);
  312.         if (rem < 0)
  313.             continue;
  314.         (void)seteuid(userid);
  315. #ifdef IP_TOS
  316.         tos = IPTOS_THROUGHPUT;
  317.         if (setsockopt(rem, IPPROTO_IP, IP_TOS,
  318.             (char *)&tos, sizeof(int)) < 0)
  319.             perror("rcp: setsockopt TOS (ignored)");
  320. #endif
  321.         sink(1, argv + argc - 1);
  322.         (void)seteuid(0);
  323.         (void)close(rem);
  324.         rem = -1;
  325.     }
  326. }
  327.  
  328. static void
  329. verifydir(const char *cp)
  330. {
  331.     struct stat stb;
  332.  
  333.     if (stat(cp, &stb) >= 0) {
  334.         if ((stb.st_mode & S_IFMT) == S_IFDIR)
  335.             return;
  336.         errno = ENOTDIR;
  337.     }
  338.     error("rcp: %s: %s.\n", cp, strerror(errno));
  339.     exit(1);
  340. }
  341.  
  342. static char *
  343. colon(char *cp)
  344. {
  345.     for (; *cp; ++cp) {
  346.         if (*cp == ':')
  347.             return(cp);
  348.         if (*cp == '/')
  349.             return NULL;
  350.     }
  351.     return NULL;
  352. }
  353.  
  354. static int
  355. okname(const char *cp0)
  356. {
  357.     const char *cp = cp0;
  358.     int c;
  359.  
  360.     do {
  361.         c = *cp;
  362.         if (c & 0200)
  363.             goto bad;
  364.         if (!isalpha(c) && !isdigit(c) && c != '_' && c != '-')
  365.             goto bad;
  366.     } while (*++cp);
  367.     return(1);
  368. bad:
  369.     (void)fprintf(stderr, "rcp: invalid user name %s\n", cp0);
  370.     return 0;
  371. }
  372.  
  373. typedef void (*sighandler)(int);
  374.  
  375. static int
  376. susystem(const char *s)
  377. {
  378.     int status, pid, w;
  379.     sighandler istat, qstat;
  380.  
  381.     if ((pid = vfork()) == 0) {
  382.         (void)setuid(userid);
  383.         execl(_PATH_BSHELL, "sh", "-c", s, NULL);
  384.         _exit(127);
  385.     }
  386.     istat = signal(SIGINT, SIG_IGN);
  387.     qstat = signal(SIGQUIT, SIG_IGN);
  388.     while ((w = wait(&status)) != pid && w != -1)
  389.         ;
  390.     if (w == -1)
  391.         status = -1;
  392.     (void)signal(SIGINT, istat);
  393.     (void)signal(SIGQUIT, qstat);
  394.     return(status);
  395. }
  396.  
  397. static void
  398. source(int argc, char *argv[])
  399. {
  400.     struct stat stb;
  401.     static BUF buffer;
  402.     BUF *bp;
  403.     off_t i;
  404.     int x, readerr, f, amt;
  405.     char *last, *name, buf[BUFSIZ];
  406.  
  407.     for (x = 0; x < argc; x++) {
  408.         name = argv[x];
  409.         if ((f = open(name, O_RDONLY, 0)) < 0) {
  410.             error("rcp: %s: %s\n", name, strerror(errno));
  411.             continue;
  412.         }
  413.         if (fstat(f, &stb) < 0)
  414.             goto notreg;
  415.         switch (stb.st_mode&S_IFMT) {
  416.  
  417.         case S_IFREG:
  418.             break;
  419.  
  420.         case S_IFDIR:
  421.             if (iamrecursive) {
  422.                 (void)close(f);
  423.                 rsource(name, &stb);
  424.                 continue;
  425.             }
  426.             /* FALLTHROUGH */
  427.         default:
  428. notreg:            (void)close(f);
  429.             error("rcp: %s: not a plain file\n", name);
  430.             continue;
  431.         }
  432.         last = strrchr(name, '/');
  433.         if (last == 0)
  434.             last = name;
  435.         else
  436.             last++;
  437.         if (pflag) {
  438.             /*
  439.              * Make it compatible with possible future
  440.              * versions expecting microseconds.
  441.              */
  442.             (void)snprintf(buf, sizeof(buf),
  443.                 "T%ld 0 %ld 0\n", stb.st_mtime, stb.st_atime);
  444.             (void)write(rem, buf, (int)strlen(buf));
  445.             if (response() < 0) {
  446.                 (void)close(f);
  447.                 continue;
  448.             }
  449.         }
  450.         (void)snprintf(buf, sizeof(buf),
  451.             "C%04o %ld %s\n", stb.st_mode&07777, stb.st_size, last);
  452.         (void)write(rem, buf, (int)strlen(buf));
  453.         if (response() < 0) {
  454.             (void)close(f);
  455.             continue;
  456.         }
  457.         if ((bp = allocbuf(&buffer, f, BUFSIZ)) == 0) {
  458.             (void)close(f);
  459.             continue;
  460.         }
  461.         readerr = 0;
  462.         for (i = 0; i < stb.st_size; i += bp->cnt) {
  463.             amt = bp->cnt;
  464.             if (i + amt > stb.st_size)
  465.                 amt = stb.st_size - i;
  466.             if (readerr == 0 && read(f, bp->buf, amt) != amt)
  467.                 readerr = errno;
  468.             (void)write(rem, bp->buf, amt);
  469.         }
  470.         (void)close(f);
  471.         if (readerr == 0)
  472.             (void)write(rem, "", 1);
  473.         else
  474.             error("rcp: %s: %s\n", name, strerror(readerr));
  475.         (void)response();
  476.     }
  477. }
  478.  
  479. static void
  480. rsource(char *name, struct stat *statp)
  481. {
  482.     DIR *dirp;
  483.     struct dirent *dp;
  484.     char *last, *vect[1], path[MAXPATHLEN];
  485.  
  486.     if (!(dirp = opendir(name))) {
  487.         error("rcp: %s: %s\n", name, strerror(errno));
  488.         return;
  489.     }
  490.     last = strrchr(name, '/');
  491.     if (last == 0)
  492.         last = name;
  493.     else
  494.         last++;
  495.     if (pflag) {
  496.         (void)snprintf(path, sizeof(path),
  497.             "T%ld 0 %ld 0\n", statp->st_mtime, statp->st_atime);
  498.         (void)write(rem, path, (int)strlen(path));
  499.         if (response() < 0) {
  500.             closedir(dirp);
  501.             return;
  502.         }
  503.     }
  504.     (void)snprintf(path, sizeof(path),
  505.         "D%04o %d %s\n", statp->st_mode&07777, 0, last);
  506.     (void)write(rem, path, (int)strlen(path));
  507.     if (response() < 0) {
  508.         closedir(dirp);
  509.         return;
  510.     }
  511.     while ((dp = readdir(dirp))!=NULL) {
  512.         if (dp->d_ino == 0)
  513.             continue;
  514.         if (!strcmp(dp->d_name, ".") || !strcmp(dp->d_name, ".."))
  515.             continue;
  516.         if (strlen(name) + 1 + strlen(dp->d_name) >= MAXPATHLEN - 1) {
  517.             error("%s/%s: name too long.\n", name, dp->d_name);
  518.             continue;
  519.         }
  520.         (void)snprintf(path, sizeof(path), "%s/%s", name, dp->d_name);
  521.         vect[0] = path;
  522.         source(1, vect);
  523.     }
  524.     closedir(dirp);
  525.     (void)write(rem, "E\n", 2);
  526.     (void)response();
  527. }
  528.  
  529. static int
  530. response(void)
  531. {
  532.     register char *cp;
  533.     char ch, resp, rbuf[BUFSIZ];
  534.  
  535.     if (read(rem, &resp, sizeof(resp)) != sizeof(resp))
  536.         lostconn(0);
  537.  
  538.     cp = rbuf;
  539.     switch(resp) {
  540.       case 0:            /* ok */
  541.         return 0;
  542.       default:
  543.         *cp++ = resp;
  544.         /* FALLTHROUGH */
  545.       case 1:            /* error, followed by err msg */
  546.       case 2:            /* fatal error, "" */
  547.         do {
  548.             if (read(rem, &ch, sizeof(ch)) != sizeof(ch))
  549.                 lostconn(0);
  550.             *cp++ = ch;
  551.         } while (cp < &rbuf[BUFSIZ] && ch != '\n');
  552.  
  553.         if (!iamremote)
  554.             write(2, rbuf, cp - rbuf);
  555.         ++errs;
  556.         if (resp == 1)
  557.             return -1;
  558.         exit(1);
  559.     }
  560.     /*NOTREACHED*/
  561.     return 0;
  562. }
  563.  
  564. static void
  565. lostconn(int ignore)
  566. {
  567.     if (!iamremote)
  568.         (void)fprintf(stderr, "rcp: lost connection\n");
  569.     exit(1);
  570. }
  571.  
  572. static void
  573. sink(int argc, char *argv[])
  574. {
  575.     register char *cp;
  576.     static BUF buffer;
  577.     struct stat stb;
  578.     struct timeval tv[2];
  579.     enum { YES, NO, DISPLAYED } wrerr;
  580.     BUF *bp;
  581.     off_t i, j;
  582.     char ch, *targ, *why;
  583.     int amt, count, exists, first, mask, mode;
  584.     int ofd, setimes, size, targisdir;
  585.     char *np, *vect[1], buf[BUFSIZ];
  586.  
  587. #define    atime    tv[0]
  588. #define    mtime    tv[1]
  589. #define    SCREWUP(str)    { why = str; goto screwup; }
  590.  
  591.     setimes = targisdir = 0;
  592.     mask = umask(0);
  593.     if (!pflag)
  594.         (void)umask(mask);
  595.     if (argc != 1) {
  596.         error("rcp: ambiguous target\n");
  597.         exit(1);
  598.     }
  599.     targ = *argv;
  600.     if (targetshouldbedirectory)
  601.         verifydir(targ);
  602.     (void)write(rem, "", 1);
  603.     if (stat(targ, &stb) == 0 && (stb.st_mode & S_IFMT) == S_IFDIR)
  604.         targisdir = 1;
  605.     for (first = 1;; first = 0) {
  606.         cp = buf;
  607.         if (read(rem, cp, 1) <= 0)
  608.             return;
  609.         if (*cp++ == '\n')
  610.             SCREWUP("unexpected <newline>");
  611.         do {
  612.             if (read(rem, &ch, sizeof(ch)) != sizeof(ch))
  613.                 SCREWUP("lost connection");
  614.             *cp++ = ch;
  615.         } while (cp < &buf[BUFSIZ - 1] && ch != '\n');
  616.         *cp = 0;
  617.  
  618.         if (buf[0] == '\01' || buf[0] == '\02') {
  619.             if (iamremote == 0)
  620.                 (void)write(2, buf + 1, (int)strlen(buf + 1));
  621.             if (buf[0] == '\02')
  622.                 exit(1);
  623.             errs++;
  624.             continue;
  625.         }
  626.         if (buf[0] == 'E') {
  627.             (void)write(rem, "", 1);
  628.             return;
  629.         }
  630.  
  631.         if (ch == '\n')
  632.             *--cp = 0;
  633.  
  634. #define getnum(t) (t) = 0; while (isdigit(*cp)) (t) = (t) * 10 + (*cp++ - '0');
  635.         cp = buf;
  636.         if (*cp == 'T') {
  637.             setimes++;
  638.             cp++;
  639.             getnum(mtime.tv_sec);
  640.             if (*cp++ != ' ')
  641.                 SCREWUP("mtime.sec not delimited");
  642.             getnum(mtime.tv_usec);
  643.             if (*cp++ != ' ')
  644.                 SCREWUP("mtime.usec not delimited");
  645.             getnum(atime.tv_sec);
  646.             if (*cp++ != ' ')
  647.                 SCREWUP("atime.sec not delimited");
  648.             getnum(atime.tv_usec);
  649.             if (*cp++ != '\0')
  650.                 SCREWUP("atime.usec not delimited");
  651.             (void)write(rem, "", 1);
  652.             continue;
  653.         }
  654.         if (*cp != 'C' && *cp != 'D') {
  655.             /*
  656.              * Check for the case "rcp remote:foo\* local:bar".
  657.              * In this case, the line "No match." can be returned
  658.              * by the shell before the rcp command on the remote is
  659.              * executed so the ^Aerror_message convention isn't
  660.              * followed.
  661.              */
  662.             if (first) {
  663.                 error("%s\n", cp);
  664.                 exit(1);
  665.             }
  666.             SCREWUP("expected control record");
  667.         }
  668.         mode = 0;
  669.         for (++cp; cp < buf + 5; cp++) {
  670.             if (*cp < '0' || *cp > '7')
  671.                 SCREWUP("bad mode");
  672.             mode = (mode << 3) | (*cp - '0');
  673.         }
  674.         if (*cp++ != ' ')
  675.             SCREWUP("mode not delimited");
  676.         size = 0;
  677.         while (isdigit(*cp))
  678.             size = size * 10 + (*cp++ - '0');
  679.         if (*cp++ != ' ')
  680.             SCREWUP("size not delimited");
  681.         if (targisdir) {
  682.             static char *namebuf;
  683.             static int cursize;
  684.             size_t need;
  685.  
  686.             need = strlen(targ) + strlen(cp) + 250;
  687.             if (need > cursize) {
  688.                 if (!(namebuf = malloc(need)))
  689.                     error("out of memory\n");
  690.             }
  691.             (void)snprintf(namebuf, need, "%s%s%s", targ,
  692.                 *targ ? "/" : "", cp);
  693.             np = namebuf;
  694.         }
  695.         else
  696.             np = targ;
  697.         exists = stat(np, &stb) == 0;
  698.         if (buf[0] == 'D') {
  699.             if (exists) {
  700.                 if ((stb.st_mode&S_IFMT) != S_IFDIR) {
  701.                     errno = ENOTDIR;
  702.                     goto bad;
  703.                 }
  704.                 if (pflag)
  705.                     (void)chmod(np, mode);
  706.             } else if (mkdir(np, mode) < 0)
  707.                 goto bad;
  708.             vect[0] = np;
  709.             sink(1, vect);
  710.             if (setimes) {
  711.                 setimes = 0;
  712.                 if (utimes(np, tv) < 0)
  713.                     error("rcp: can't set times on %s: %s\n",
  714.                     np, strerror(errno));
  715.             }
  716.             continue;
  717.         }
  718.         if ((ofd = open(np, O_WRONLY|O_CREAT, mode)) < 0) {
  719. bad:            error("rcp: %s: %s\n", np, strerror(errno));
  720.             continue;
  721.         }
  722.         if (exists && pflag)
  723.             (void)fchmod(ofd, mode);
  724.         (void)write(rem, "", 1);
  725.         if ((bp = allocbuf(&buffer, ofd, BUFSIZ)) == 0) {
  726.             (void)close(ofd);
  727.             continue;
  728.         }
  729.         cp = bp->buf;
  730.         count = 0;
  731.         wrerr = NO;
  732.         for (i = 0; i < size; i += BUFSIZ) {
  733.             amt = BUFSIZ;
  734.             if (i + amt > size)
  735.                 amt = size - i;
  736.             count += amt;
  737.             do {
  738.                 j = read(rem, cp, amt);
  739.                 if (j <= 0) {
  740.                     error("rcp: %s\n",
  741.                         j ? strerror(errno) :
  742.                         "dropped connection");
  743.                     exit(1);
  744.                 }
  745.                 amt -= j;
  746.                 cp += j;
  747.             } while (amt > 0);
  748.             if (count == bp->cnt) {
  749.                 if (wrerr == NO &&
  750.                     write(ofd, bp->buf, count) != count)
  751.                     wrerr = YES;
  752.                 count = 0;
  753.                 cp = bp->buf;
  754.             }
  755.         }
  756.         if (count != 0 && wrerr == NO &&
  757.             write(ofd, bp->buf, count) != count)
  758.             wrerr = YES;
  759.         if (ftruncate(ofd, size)) {
  760.             error("rcp: can't truncate %s: %s\n", np,
  761.                 strerror(errno));
  762.             wrerr = DISPLAYED;
  763.         }
  764.         (void)close(ofd);
  765.         (void)response();
  766.         if (setimes && wrerr == NO) {
  767.             setimes = 0;
  768.             if (utimes(np, tv) < 0) {
  769.                 error("rcp: can't set times on %s: %s\n",
  770.                     np, strerror(errno));
  771.                 wrerr = DISPLAYED;
  772.             }
  773.         }
  774.         switch(wrerr) {
  775.         case YES:
  776.             error("rcp: %s: %s\n", np, strerror(errno));
  777.             break;
  778.         case NO:
  779.             (void)write(rem, "", 1);
  780.             break;
  781.         case DISPLAYED:
  782.             break;
  783.         }
  784.     }
  785. screwup:
  786.     error("rcp: protocol screwup: %s\n", why);
  787.     exit(1);
  788. }
  789.  
  790. static BUF *
  791. allocbuf(BUF *bp, int fd, int blksize)
  792. {
  793.     struct stat stb;
  794.     size_t size;
  795.  
  796.     if (fstat(fd, &stb) < 0) {
  797.         error("rcp: fstat: %s\n", strerror(errno));
  798.         return(0);
  799.     }
  800.     size = roundup(stb.st_blksize, blksize);
  801.     if (size == 0)
  802.         size = blksize;
  803.     if (bp->cnt < size) {
  804.         if (bp->buf != 0)
  805.             free(bp->buf);
  806.         bp->buf = malloc(size);
  807.         if (!bp->buf) {
  808.             error("rcp: malloc: out of memory\n");
  809.             return NULL;
  810.         }
  811.     }
  812.     bp->cnt = size;
  813.     return(bp);
  814. }
  815.  
  816. void
  817. error(const char *fmt, ...)
  818. {
  819.     static FILE *fp;
  820.     va_list ap;
  821.  
  822.     va_start(ap, fmt);
  823.  
  824.     ++errs;
  825.     if (!fp && !(fp = fdopen(rem, "w")))
  826.         return;
  827.     fprintf(fp, "%c", 0x01);
  828.     vfprintf(fp, fmt, ap);
  829.     fflush(fp);
  830.     if (!iamremote)    vfprintf(stderr, fmt, ap);
  831.  
  832.     va_end(ap);
  833. }
  834.  
  835. static void 
  836. nospace(void)
  837. {
  838.     (void)fprintf(stderr, "rcp: out of memory.\n");
  839.     exit(1);
  840. }
  841.  
  842. static void
  843. usage(void)
  844. {
  845.     (void)fprintf(stderr,
  846.         "usage: rcp [-p] f1 f2; or: rcp [-rp] f1 ... fn directory\n");
  847.     exit(1);
  848. }
  849.